package test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.ApplicationWindow;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;

public class PlayerTable extends ApplicationWindow {
	  // The data model
	  private PlayerTableModel model;

	  // The table viewer
	  private TableViewer tv;

	  /**
	   * Constructs a PlayerTable
	   */
	  public PlayerTable() {
	    super(null);
	    model = new PlayerTableModel();
	  }

	  /**
	   * Runs the application
	   */
	  public void run() {
	    // Don't return from open() until window closes
	    setBlockOnOpen(true);

	    // Open the main window
	    open();

	    // Dispose the display
	    Display.getCurrent().dispose();
	  }

	  /**
	   * Configures the shell
	   * 
	   * @param shell
	   *            the shell
	   */
	  protected void configureShell(Shell shell) {
	    super.configureShell(shell);
	    shell.setSize(400, 400);
	  }

	  /**
	   * Creates the main window's contents
	   * 
	   * @param parent
	   *            the main window
	   * @return Control
	   */
	  protected Control createContents(Composite parent) {
	    // Create the composite to hold the controls
	    Composite composite = new Composite(parent, SWT.NONE | SWT.V_SCROLL);
	    composite.setLayout(new GridLayout(1, false));

	    // Create the combo to hold the team names
	    Combo combo = new Combo(composite, SWT.READ_ONLY);
	    combo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

	    // Create the table viewer to display the players
	    tv = new TableViewer(composite);

	    // Set the content and label providers
	    tv.setContentProvider(new PlayerContentProvider());
	    tv.setLabelProvider(new PlayerLabelProvider());
	    tv.setSorter(new PlayerViewerSorter());

	    // Set up the table
	    Table table = tv.getTable();
	    table.setLayoutData(new GridData(GridData.FILL_BOTH));

	    // Add the first name column
	    TableColumn tc = new TableColumn(table, SWT.LEFT);
	    tc.setText("First Name");
	    tc.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        ((PlayerViewerSorter) tv.getSorter())
	            .doSort(PlayerConst.COLUMN_FIRST_NAME);
	        tv.refresh();
	      }
	    });

	    // Add the last name column
	    tc = new TableColumn(table, SWT.LEFT);
	    tc.setText("Last Name");
	    tc.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        ((PlayerViewerSorter) tv.getSorter())
	            .doSort(PlayerConst.COLUMN_LAST_NAME);
	        tv.refresh();
	      }
	    });

	    // Add the points column
	    tc = new TableColumn(table, SWT.RIGHT);
	    tc.setText("Points");
	    tc.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        ((PlayerViewerSorter) tv.getSorter())
	            .doSort(PlayerConst.COLUMN_POINTS);
	        tv.refresh();
	      }
	    });

	    // Add the rebounds column
	    tc = new TableColumn(table, SWT.RIGHT);
	    tc.setText("Rebounds");
	    tc.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        ((PlayerViewerSorter) tv.getSorter())
	            .doSort(PlayerConst.COLUMN_REBOUNDS);
	        tv.refresh();
	      }
	    });

	    // Add the assists column
	    tc = new TableColumn(table, SWT.RIGHT);
	    tc.setText("Assists");
	    tc.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        ((PlayerViewerSorter) tv.getSorter())
	            .doSort(PlayerConst.COLUMN_ASSISTS);
	        tv.refresh();
	      }
	    });

	    // Add the team names to the combo
	    for (int i = 0, n = model.teams.length; i < n; i++) {
	      combo.add(model.teams[i].getName());
	    }

	    // Add a listener to change the tableviewer's input
	    combo.addSelectionListener(new SelectionAdapter() {
	      public void widgetSelected(SelectionEvent event) {
	        update(model.teams[((Combo) event.widget).getSelectionIndex()]);
	      }
	    });

	    // Select the first item
	    combo.select(0);
	    update(model.teams[0]);

	    // Pack the columns
	    for (int i = 0, n = table.getColumnCount(); i < n; i++) {
	      table.getColumn(i).pack();
	    }

	    // Turn on the header and the lines
	    table.setHeaderVisible(true);
	    table.setLinesVisible(true);

	    return composite;
	  }

	  /**
	   * Updates the application with the selected team
	   * 
	   * @param team
	   *            the team
	   */
	  private void update(Team team) {
	    // Update the window's title bar with the new team
	    getShell().setText(team.getYear() + " " + team.getName());

	    // Set the table viewer's input to the team
	    tv.setInput(team);
	  }

	  /**
	   * The application entry point
	   * 
	   * @param args
	   *            the command line arguments
	   */
	  public static void main(String[] args) {
	    new PlayerTable().run();
	  }
	}

	/**
	 * This class contains the data model for the PlayerTable
	 */

	class PlayerTableModel {
	  public Team[] teams;

	  /**
	   * Constructs a PlayerTableModel Fills the model with data
	   */
	  public PlayerTableModel() {
	    teams = new Team[3];

	    teams[0] = new Team("Celtics", "1985-86");
	    teams[0].add(new Player("Larry", "Bird", 25.8f, 9.8f, 6.8f));
	    teams[0].add(new Player("Kevin", "McHale", 21.3f, 8.1f, 2.7f));
	    teams[0].add(new Player("Robert", "Parish", 16.1f, 9.5f, 1.8f));
	    teams[0].add(new Player("Dennis", "Johnson", 15.6f, 3.4f, 5.8f));
	    teams[0].add(new Player("Danny", "Ainge", 10.7f, 2.9f, 5.1f));
	    teams[0].add(new Player("Scott", "Wedman", 8.0f, 2.4f, 1.1f));
	    teams[0].add(new Player("Bill", "Walton", 7.6f, 6.8f, 2.1f));
	    teams[0].add(new Player("Jerry", "Sichting", 6.5f, 1.3f, 2.3f));
	    teams[0].add(new Player("David", "Thirdkill", 3.3f, 1.4f, 0.3f));
	    teams[0].add(new Player("Sam", "Vincent", 3.2f, 0.8f, 1.2f));
	    teams[0].add(new Player("Sly", "Williams", 2.8f, 2.5f, 0.3f));
	    teams[0].add(new Player("Rick", "Carlisle", 2.6f, 1.0f, 1.4f));
	    teams[0].add(new Player("Greg", "Kite", 1.3f, 2.0f, 1.3f));

	    teams[1] = new Team("Bulls", "1995-96");
	    teams[1].add(new Player("Michael", "Jordan", 30.4f, 6.6f, 4.3f));
	    teams[1].add(new Player("Scottie", "Pippen", 19.4f, 6.4f, 5.9f));
	    teams[1].add(new Player("Toni", "Kukoc", 13.1f, 4.0f, 3.5f));
	    teams[1].add(new Player("Luc", "Longley", 9.1f, 5.1f, 1.9f));
	    teams[1].add(new Player("Steve", "Kerr", 8.4f, 1.3f, 2.3f));
	    teams[1].add(new Player("Ron", "Harper", 7.4f, 2.7f, 2.6f));
	    teams[1].add(new Player("Dennis", "Rodman", 5.5f, 14.9f, 2.5f));
	    teams[1].add(new Player("Bill", "Wennington", 5.3f, 2.5f, 0.6f));
	    teams[1].add(new Player("Jack", "Haley", 5.0f, 2.0f, 0.0f));
	    teams[1].add(new Player("John", "Salley", 4.4f, 3.3f, 1.3f));
	    teams[1].add(new Player("Jud", "Buechler", 3.8f, 1.5f, 0.8f));
	    teams[1].add(new Player("Dickey", "Simpkins", 3.6f, 2.6f, 0.6f));
	    teams[1].add(new Player("James", "Edwards", 3.5f, 1.4f, 0.4f));
	    teams[1].add(new Player("Jason", "Caffey", 3.2f, 1.9f, 0.4f));
	    teams[1].add(new Player("Randy", "Brown", 2.7f, 1.0f, 1.1f));

	    teams[2] = new Team("Lakers", "1987-1988");
	    teams[2].add(new Player("Magic", "Johnson", 23.9f, 6.3f, 12.2f));
	    teams[2].add(new Player("James", "Worthy", 19.4f, 5.7f, 2.8f));
	    teams[2].add(new Player("Kareem", "Abdul-Jabbar", 17.5f, 6.7f, 2.6f));
	    teams[2].add(new Player("Byron", "Scott", 17.0f, 3.5f, 3.4f));
	    teams[2].add(new Player("A.C.", "Green", 10.8f, 7.8f, 1.1f));
	    teams[2].add(new Player("Michael", "Cooper", 10.5f, 3.1f, 4.5f));
	    teams[2].add(new Player("Mychal", "Thompson", 10.1f, 4.1f, 0.8f));
	    teams[2].add(new Player("Kurt", "Rambis", 5.7f, 5.8f, 0.8f));
	    teams[2].add(new Player("Billy", "Thompson", 5.6f, 2.9f, 1.0f));
	    teams[2].add(new Player("Adrian", "Branch", 4.3f, 1.7f, 0.5f));
	    teams[2].add(new Player("Wes", "Matthews", 4.2f, 0.9f, 2.0f));
	    teams[2].add(new Player("Frank", "Brickowski", 4.0f, 2.6f, 0.3f));
	    teams[2].add(new Player("Mike", "Smrek", 2.2f, 1.1f, 0.1f));
	  }
	}

	/**
	 * This class represents a player
	 */

	class Player {
	  private Team team;

	  private String lastName;

	  private String firstName;

	  private float points;

	  private float rebounds;

	  private float assists;

	  /**
	   * Constructs an empty Player
	   */
	  public Player() {
	    this(null, null, 0.0f, 0.0f, 0.0f);
	  }

	  /**
	   * Constructs a Player
	   * 
	   * @param firstName
	   *            the first name
	   * @param lastName
	   *            the last name
	   * @param points
	   *            the points
	   * @param rebounds
	   *            the rebounds
	   * @param assists
	   *            the assists
	   */
	  public Player(String firstName, String lastName, float points,
	      float rebounds, float assists) {
	    setFirstName(firstName);
	    setLastName(lastName);
	    setPoints(points);
	    setRebounds(rebounds);
	    setAssists(assists);
	  }

	  /**
	   * Sets the team for theo player
	   * 
	   * @param team
	   *            the team
	   */
	  public void setTeam(Team team) {
	    this.team = team;
	  }

	  /**
	   * Gets the assists
	   * 
	   * @return float
	   */
	  public float getAssists() {
	    return assists;
	  }

	  /**
	   * Sets the assists
	   * 
	   * @param assists
	   *            The assists to set.
	   */
	  public void setAssists(float assists) {
	    this.assists = assists;
	  }

	  /**
	   * Gets the first name
	   * 
	   * @return String
	   */
	  public String getFirstName() {
	    return firstName;
	  }

	  /**
	   * Sets the first name
	   * 
	   * @param firstName
	   *            The firstName to set.
	   */
	  public void setFirstName(String firstName) {
	    this.firstName = firstName;
	  }

	  /**
	   * Gets the last name
	   * 
	   * @return String
	   */
	  public String getLastName() {
	    return lastName;
	  }

	  /**
	   * Sets the last name
	   * 
	   * @param lastName
	   *            The lastName to set.
	   */
	  public void setLastName(String lastName) {
	    this.lastName = lastName;
	  }

	  /**
	   * Gets the points
	   * 
	   * @return float
	   */
	  public float getPoints() {
	    return points;
	  }

	  /**
	   * Sets the points
	   * 
	   * @param points
	   *            The points to set.
	   */
	  public void setPoints(float points) {
	    this.points = points;
	  }

	  /**
	   * Gets the rebounds
	   * 
	   * @return float
	   */
	  public float getRebounds() {
	    return rebounds;
	  }

	  /**
	   * Sets the rebounds
	   * 
	   * @param rebounds
	   *            The rebounds to set.
	   */
	  public void setRebounds(float rebounds) {
	    this.rebounds = rebounds;
	  }

	  /**
	   * Gets the team
	   * 
	   * @return Team
	   */
	  public Team getTeam() {
	    return team;
	  }

	  /**
	   * Returns whether this player led the team in the specified category
	   * 
	   * @param column
	   *            the column (category)
	   * @return boolean
	   */
	  public boolean ledTeam(int column) {
	    return team.led(this, column);
	  }
	}
	/**
	 * This class represents a team
	 */

	class Team {
	  private String name;

	  private String year;

	  private List players;

	  /**
	   * Constructs a Team
	   * 
	   * @param name
	   *            the name
	   * @param year
	   *            the year
	   */
	  public Team(String name, String year) {
	    this.name = name;
	    this.year = year;
	    players = new LinkedList();
	  }

	  /**
	   * Gets the name
	   * 
	   * @return String
	   */
	  public String getName() {
	    return name;
	  }

	  /**
	   * Gets the year
	   * 
	   * @return String
	   */
	  public String getYear() {
	    return year;
	  }

	  /**
	   * Adds a player
	   * 
	   * @param player
	   *            the player to add
	   * @return boolean
	   */
	  public boolean add(Player player) {
	    boolean added = players.add(player);
	    if (added)
	      player.setTeam(this);
	    return added;
	  }

	  /**
	   * Gets the players
	   * 
	   * @return List
	   */
	  public List getPlayers() {
	    return Collections.unmodifiableList(players);
	  }

	  /**
	   * Returns whether the specified player led his team in the specified
	   * category
	   * 
	   * @param player
	   *            the player
	   * @param column
	   *            the category
	   * @return boolean
	   */
	  public boolean led(Player player, int column) {
	    boolean led = true;

	    // Go through all the players on the team, comparing the specified
	    // player's
	    // stats with each other player.
	    for (int i = 0, n = players.size(); i < n && led; i++) {
	      Player test = (Player) players.get(i);
	      if (player == test)
	        continue;
	      switch (column) {
	      case PlayerConst.COLUMN_POINTS:
	        if (player.getPoints() < test.getPoints())
	          led = false;
	        break;
	      case PlayerConst.COLUMN_REBOUNDS:
	        if (player.getRebounds() < test.getRebounds())
	          led = false;
	        break;
	      case PlayerConst.COLUMN_ASSISTS:
	        if (player.getAssists() < test.getAssists())
	          led = false;
	        break;
	      }
	    }
	    return led;
	  }
	}

	/**
	 * This class implements the sorting for the Player Table
	 */

	class PlayerViewerSorter extends ViewerSorter {
	  private static final int ASCENDING = 0;

	  private static final int DESCENDING = 1;

	  private int column;

	  private int direction;

	  /**
	   * Does the sort. If it's a different column from the previous sort, do an
	   * ascending sort. If it's the same column as the last sort, toggle the sort
	   * direction.
	   * 
	   * @param column
	   */
	  public void doSort(int column) {
	    if (column == this.column) {
	      // Same column as last sort; toggle the direction
	      direction = 1 - direction;
	    } else {
	      // New column; do an ascending sort
	      this.column = column;
	      direction = ASCENDING;
	    }
	  }

	  /**
	   * Compares the object for sorting
	   */
	  public int compare(Viewer viewer, Object e1, Object e2) {
	    int rc = 0;
	    Player p1 = (Player) e1;
	    Player p2 = (Player) e2;

	    // Determine which column and do the appropriate sort
	    switch (column) {
	    case PlayerConst.COLUMN_FIRST_NAME:
	      rc = collator.compare(p1.getFirstName(), p2.getFirstName());
	      break;
	    case PlayerConst.COLUMN_LAST_NAME:
	      rc = collator.compare(p1.getLastName(), p2.getLastName());
	      break;
	    case PlayerConst.COLUMN_POINTS:
	      rc = p1.getPoints() > p2.getPoints() ? 1 : -1;
	      break;
	    case PlayerConst.COLUMN_REBOUNDS:
	      rc = p1.getRebounds() > p2.getRebounds() ? 1 : -1;
	      break;
	    case PlayerConst.COLUMN_ASSISTS:
	      rc = p1.getAssists() > p2.getAssists() ? 1 : -1;
	      break;
	    }

	    // If descending order, flip the direction
	    if (direction == DESCENDING)
	      rc = -rc;

	    return rc;
	  }
	}

	/**
	 * This class contains constants for the PlayerTable application
	 */

	class PlayerConst {
	  // Column constants
	  public static final int COLUMN_FIRST_NAME = 0;

	  public static final int COLUMN_LAST_NAME = 1;

	  public static final int COLUMN_POINTS = 2;

	  public static final int COLUMN_REBOUNDS = 3;

	  public static final int COLUMN_ASSISTS = 4;
	}

	/**
	 * This class provides the labels for the person table
	 */

	class PersonLabelProvider implements ITableLabelProvider {
	  /**
	   * Returns the image
	   * 
	   * @param element
	   *            the element
	   * @param columnIndex
	   *            the column index
	   * @return Image
	   */
	  public Image getColumnImage(Object element, int columnIndex) {
	    return null;
	  }

	  /**
	   * Returns the column text
	   * 
	   * @param element
	   *            the element
	   * @param columnIndex
	   *            the column index
	   * @return String
	   */
	  public String getColumnText(Object element, int columnIndex) {
	    Person person = (Person) element;
	    switch (columnIndex) {
	    case 0:
	      return person.getName();
	    case 1:
	      return Boolean.toString(person.isMale());
	    case 2:
	      return AgeRange.INSTANCES[person.getAgeRange().intValue()];
	    case 3:
	      return person.getShirtColor().toString();
	    }
	    return null;
	  }

	  /**
	   * Adds a listener
	   * 
	   * @param listener
	   *            the listener
	   */
	  public void addListener(ILabelProviderListener listener) {
	    // Ignore it
	  }

	  /**
	   * Disposes any created resources
	   */
	  public void dispose() {
	    // Nothing to dispose
	  }

	  /**
	   * Returns whether altering this property on this element will affect the
	   * label
	   * 
	   * @param element
	   *            the element
	   * @param property
	   *            the property
	   * @return boolean
	   */
	  public boolean isLabelProperty(Object element, String property) {
	    return false;
	  }

	  /**
	   * Removes a listener
	   * 
	   * @param listener
	   *            the listener
	   */
	  public void removeListener(ILabelProviderListener listener) {
	    // Ignore
	  }
	}

	/**
	 * This class represents a person
	 */

	class Person {
	  private String name;

	  private boolean male;

	  private Integer ageRange;

	  private RGB shirtColor;

	  /**
	   * @return Returns the ageRange.
	   */
	  public Integer getAgeRange() {
	    return ageRange;
	  }

	  /**
	   * @param ageRange
	   *            The ageRange to set.
	   */
	  public void setAgeRange(Integer ageRange) {
	    this.ageRange = ageRange;
	  }

	  /**
	   * @return Returns the male.
	   */
	  public boolean isMale() {
	    return male;
	  }

	  /**
	   * @param male
	   *            The male to set.
	   */
	  public void setMale(boolean male) {
	    this.male = male;
	  }

	  /**
	   * @return Returns the name.
	   */
	  public String getName() {
	    return name;
	  }

	  /**
	   * @param name
	   *            The name to set.
	   */
	  public void setName(String name) {
	    this.name = name;
	  }

	  /**
	   * @return Returns the shirtColor.
	   */
	  public RGB getShirtColor() {
	    return shirtColor;
	  }

	  /**
	   * @param shirtColor
	   *            The shirtColor to set.
	   */
	  public void setShirtColor(RGB shirtColor) {
	    this.shirtColor = shirtColor;
	  }
	}

	/**
	 * This class encapsulates age ranges
	 */

	class AgeRange {
	  public static final String NONE = "";

	  public static final String BABY = "0 - 3";

	  public static final String TODDLER = "4 - 7";

	  public static final String CHILD = "8 - 12";

	  public static final String TEENAGER = "13 - 19";

	  public static final String ADULT = "20 - ?";

	  public static final String[] INSTANCES = { NONE, BABY, TODDLER, CHILD,
	      TEENAGER, ADULT };
	}

	/**
	 * This class provides the labels for PlayerTable
	 */

	class PlayerLabelProvider implements ITableLabelProvider {
	  // Image to display if the player led his team
	  private Image ball;

	  // Constructs a PlayerLabelProvider
	  public PlayerLabelProvider() {
	    // Create the image
	    try {
	      ball = new Image(null, new FileInputStream("images/ball.png"));
	    } catch (FileNotFoundException e) {
	      // Swallow it
	    }
	  }

	  /**
	   * Gets the image for the specified column
	   * 
	   * @param arg0
	   *            the player
	   * @param arg1
	   *            the column
	   * @return Image
	   */
	  public Image getColumnImage(Object arg0, int arg1) {
	    Player player = (Player) arg0;
	    Image image = null;
	    switch (arg1) {
	    // A player can't lead team in first name or last name
	    case PlayerConst.COLUMN_POINTS:
	    case PlayerConst.COLUMN_REBOUNDS:
	    case PlayerConst.COLUMN_ASSISTS:
	      if (player.ledTeam(arg1))
	        // Set the image
	        image = ball;
	      break;
	    }
	    return image;
	  }

	  /**
	   * Gets the text for the specified column
	   * 
	   * @param arg0
	   *            the player
	   * @param arg1
	   *            the column
	   * @return String
	   */
	  public String getColumnText(Object arg0, int arg1) {
	    Player player = (Player) arg0;
	    String text = "";
	    switch (arg1) {
	    case PlayerConst.COLUMN_FIRST_NAME:
	      text = player.getFirstName();
	      break;
	    case PlayerConst.COLUMN_LAST_NAME:
	      text = player.getLastName();
	      break;
	    case PlayerConst.COLUMN_POINTS:
	      text = String.valueOf(player.getPoints());
	      break;
	    case PlayerConst.COLUMN_REBOUNDS:
	      text = String.valueOf(player.getRebounds());
	      break;
	    case PlayerConst.COLUMN_ASSISTS:
	      text = String.valueOf(player.getAssists());
	      break;
	    }
	    return text;
	  }

	  /**
	   * Adds a listener
	   * 
	   * @param arg0
	   *            the listener
	   */
	  public void addListener(ILabelProviderListener arg0) {
	    // Throw it away
	  }

	  /**
	   * Dispose any created resources
	   */
	  public void dispose() {
	    // Dispose the image
	    if (ball != null)
	      ball.dispose();
	  }

	  /**
	   * Returns whether the specified property, if changed, would affect the
	   * label
	   * 
	   * @param arg0
	   *            the player
	   * @param arg1
	   *            the property
	   * @return boolean
	   */
	  public boolean isLabelProperty(Object arg0, String arg1) {
	    return false;
	  }

	  /**
	   * Removes the specified listener
	   * 
	   * @param arg0
	   *            the listener
	   */
	  public void removeListener(ILabelProviderListener arg0) {
	    // Do nothing
	  }
	}

	/**
	 * This class provides the content for the table
	 */

	class PlayerContentProvider implements IStructuredContentProvider {

	  /**
	   * Gets the elements for the table
	   * 
	   * @param arg0
	   *            the model
	   * @return Object[]
	   */
	  public Object[] getElements(Object arg0) {
	    // Returns all the players in the specified team
	    return ((Team) arg0).getPlayers().toArray();
	  }

	  /**
	   * Disposes any resources
	   */
	  public void dispose() {
	    // We don't create any resources, so we don't dispose any
	  }

	  /**
	   * Called when the input changes
	   * 
	   * @param arg0
	   *            the parent viewer
	   * @param arg1
	   *            the old input
	   * @param arg2
	   *            the new input
	   */
	  public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
	    // Nothing to do
	  }
	}
